home *** CD-ROM | disk | FTP | other *** search
/ Ultimedia 1 / Ultimedia 1.iso / tools / grafiktools / showpicasso / source / sp_iff.c < prev    next >
Encoding:
Text File  |  1994-06-26  |  10.3 KB  |  553 lines
  1. /* Routinen für IFF ILBM-Dateien
  2. ** File: spiff.c
  3. */
  4.  
  5.  
  6. /* Unterroutine zum Test auf FORM ILBM, RGBN und RGB8 */
  7.  
  8.  
  9. BYTE IsIFF(struct IFFHandle *iff)
  10. {
  11.  LONG              error = NULL;
  12.  struct ContextNode *top = NULL;
  13.  
  14.  if(!(error=ParseIFF(iff,IFFPARSE_RAWSTEP)))
  15.  {
  16.  
  17.   if(top=CurrentChunk(iff))
  18.   {
  19.  
  20.    if((top->cn_Type) == ID_ILBM) return(1L);
  21.    if((top->cn_Type) == MAKE_ID('R','G','B','N')) return(2L);
  22.    if((top->cn_Type) == MAKE_ID('R','G','B','8')) return(3L);
  23.   }
  24.  }
  25.  else 
  26.  {
  27.   if(error != -10L) OutText(localstr[MSG_EPARSEIFF]);
  28.  }
  29.  
  30.  return(NULL);
  31. }
  32.  
  33.  
  34. /* Einlesen des BMHD Chunk in die Struktur */
  35.  
  36.  
  37. BOOL GetBMHD(struct IFFHandle *iff,BitMapHeader *bmap)
  38. {
  39.  if(ReadChunkBytes(iff,bmap,20L) == 20L) return(TRUE);
  40.  return(FALSE);
  41. }
  42.  
  43.  
  44. /* Einlesen des CAMG Chunk */
  45.  
  46.  
  47. BOOL GetCAMG(struct IFFHandle *iff,ULONG *mode)
  48. {
  49.  if(ReadChunkBytes(iff,mode,4L) == 4L) return(TRUE);
  50.  return(FALSE);
  51. }
  52.  
  53.  
  54. /* Einlesen des CMAP Chunk in ColorRegister */
  55.  
  56.  
  57. BOOL GetCMAP(struct IFFHandle *iff,UBYTE *creg,LONG cnum)
  58. { 
  59.  if(ReadChunkBytes(iff,creg,3*cnum) == 3*cnum) return(TRUE);
  60.  return(FALSE);
  61. }
  62.  
  63.  
  64. /* Einlesen des BODY Chunk aus einer IFF ILBM Datei */
  65.  
  66.  
  67. LONG GetBODY_ILBM(struct IFFHandle *iff,BitMapHeader *bmap,ULONG mode,struct Screen *scr)
  68. {
  69.  UWORD        width = scr->Width; /* screen width */
  70.  UWORD      height = scr->Height; /* screen height */
  71.  
  72.  LONG                  ok = TRUE;
  73.  LONG              actual = NULL;
  74.  LONG                     bcount;
  75.  UWORD                    bpline; /* Anzahl der Bytes in einer Zeile */
  76.  LONG           pixoffset = NULL;
  77.  UWORD                    wpline; /* Anzahl der Words in einer Zeile */
  78.  WORD             gfxmode = NULL;
  79.  register WORD       min128=-128;
  80.  register LONG srcbytes,dstbytes;
  81.  register BYTE           *source;
  82.  register BYTE             *dest;
  83.  register BYTE          *scrbase;
  84.  register UWORD     *sbuf = NULL; /* Buffer für eine Bildzeile */
  85.  register UBYTE   *hambuf = NULL; /* Buffer für eine HAM Bildzeile */
  86.  register WORD           c,h,p,n;
  87.  
  88.  gfxmode = 8;
  89.  
  90.  if(mode & HAM_KEY)
  91.  {
  92.   if(bmap->nPlanes == 6) gfxmode = 12;
  93.   if(bmap->nPlanes == 8) gfxmode = 23;
  94.  }
  95.  
  96.  if(USERFLGS & PFLG_TRUECLR)              
  97.  {
  98.   gfxmode = 24;
  99.   if(USERFLGS & PFLG_TC15BIT) gfxmode = 15;
  100.   if(USERFLGS & PFLG_TC16BIT) gfxmode = 16;
  101.  }
  102.  
  103.  bpline = (ULONG)(bmap->w / 8);
  104.  if(((LONG)bmap->w) % 8) bpline++;
  105.  if(((LONG)bpline) % 2) bpline++;
  106.  
  107.  bcount = (bmap->nPlanes) * bpline;
  108.  wpline = bpline / 2;
  109.  
  110.  scrbase = LockVillageScreen(scr);
  111.  
  112.  if(!(USERFLGS & UFLG_NOCENTER)) /* Zentrierung des Bildes auf dem Screen */
  113.  {
  114.   switch(gfxmode)
  115.   {
  116.    case 8:
  117.  
  118.    scrbase += (((height) - (bmap->h)) / 2 * (width)) + (((width) - (bmap->w)) / 2);
  119.    break;
  120.  
  121.    case 12:
  122.    case 15:
  123.    case 16:
  124.  
  125.    scrbase += (((height) - (bmap->h)) / 2 * (width) * 2) + (((width) - (bmap->w)) / 2 * 2);
  126.    break;
  127.  
  128.    case 23:
  129.    case 24:
  130.  
  131.    scrbase += (((height) - (bmap->h)) / 2 * (width) * 3) + (((width) - (bmap->w)) / 2 * 3);
  132.    break;
  133.   }
  134.  }
  135.  
  136.  if(sbuf = AllocVec((ULONG)(bpline*(UWORD)bmap->nPlanes),MEMF_PUBLIC|MEMF_CLEAR))
  137.  {
  138.  
  139.   if(mode & HAM_KEY) 
  140.   {
  141.    if(!(hambuf = AllocVec((ULONG)bmap->w,MEMF_PUBLIC|MEMF_CLEAR)))
  142.    {
  143.     ok = FALSE;
  144.     goto ByteError;
  145.    }
  146.   }
  147.  
  148.   if(bmap->compression)
  149.   {
  150.    srcbytes = ReadChunkBytes(iff,cbuf,cbufsize); /* Lesen der Daten nach cbuf */
  151.    source = cbuf;
  152.   }
  153.  
  154.   for(h=0; h < (bmap->h); h++)
  155.   {
  156.  
  157.    if(bmap->compression) 
  158.    {
  159.     dest = (BYTE *)sbuf;
  160.  
  161.     for(p=0; p < (bmap->nPlanes); p++)
  162.     {
  163.      dstbytes = bpline;
  164.  
  165.      while(dstbytes > 0)
  166.      {
  167.  
  168.       if((srcbytes -= 1) < 0)
  169.       {
  170.  
  171.        if((srcbytes = ReadChunkBytes(iff,cbuf,cbufsize) - 1) < 0)
  172.        {
  173.         ok = FALSE;
  174.         goto ByteError;
  175.        }
  176.        source = cbuf;
  177.       }
  178.  
  179.       n = *source++;
  180.      
  181.       if(n >= 0)
  182.       {
  183.        n += 1;
  184.  
  185.        if((srcbytes -= n) < 0) 
  186.        {
  187.         srcbytes += n;
  188.  
  189.         for(c=0; c < srcbytes; c++) cbuf[c] = *source++;
  190.  
  191.         if(ReadChunkBytes(iff,&cbuf[srcbytes],cbufsize - srcbytes) < 0) 
  192.         {
  193.          ok = FALSE;
  194.          goto ByteError;
  195.         }
  196.         srcbytes = cbufsize-n;
  197.         source = cbuf;
  198.        }
  199.  
  200.        if((dstbytes -= n) < 0) break;
  201.        do (*dest++ = *source++); while(--n > 0);
  202.       }
  203.  
  204.       else if(n != min128)
  205.       {
  206.        n = -n + 1;
  207.  
  208.        if((srcbytes -= 1) < 0)
  209.        {
  210.  
  211.         if((srcbytes = ReadChunkBytes(iff,cbuf,cbufsize) - 1) < 0)
  212.         {
  213.          ok = FALSE;
  214.          goto ByteError;
  215.         }
  216.         source = cbuf;
  217.        }
  218.  
  219.        if((dstbytes -= n) < 0) break;
  220.        c = *source++;
  221.        do *dest++ = c; while(--n > 0);
  222.       }
  223.      }
  224.     }
  225.    }
  226.    else actual = ReadChunkBytes(iff,sbuf,bcount);
  227.  
  228.    switch(gfxmode)
  229.    {
  230.     case 8:
  231.  
  232.     Convert8(&scrbase[pixoffset],sbuf,bmap->nPlanes,bpline);
  233.     pixoffset += width;
  234.     break;
  235.  
  236.     case 12:
  237.  
  238.     ConvertHAM6(&scrbase[pixoffset],sbuf,hambuf,color,bpline);
  239.     pixoffset += width*2;
  240.     break;
  241.  
  242.  
  243.     case 15:
  244.  
  245.     Convert15(&scrbase[pixoffset],sbuf,bpline);
  246.     pixoffset += width*2;
  247.     break;
  248.  
  249.     case 16:
  250.  
  251.     Convert16(&scrbase[pixoffset],sbuf,bpline);
  252.     pixoffset += width*2;
  253.     break;
  254.  
  255.     case 23:
  256.  
  257.     ConvertHAM8(&scrbase[pixoffset],sbuf,hambuf,color,bpline);
  258.     pixoffset += width*3;
  259.     break;
  260.     
  261.     case 24:
  262.  
  263.     Convert24(&scrbase[pixoffset],sbuf,bpline);
  264.     pixoffset += width*3;
  265.     break;
  266.  
  267.    }
  268.   }
  269.  
  270. ByteError:
  271.  
  272.   if(hambuf) FreeVec(hambuf);
  273.   FreeVec(sbuf);
  274.  }
  275.  
  276.  UnLockVillageScreen(scr); 
  277.  
  278.  return(ok);
  279. }
  280.  
  281.  
  282. /* Einlesen des BODY Chunk aus einer IFF RGBN bzw. RGB8 Datei */
  283.  
  284. LONG GetBODY_RGBx(struct IFFHandle *iff,BitMapHeader *bmap,struct Screen *scr)
  285. {
  286.  UWORD        width = scr->Width;
  287.  UWORD      height = scr->Height;
  288.  
  289.  LONG                  ok = TRUE;
  290.  LONG             pixoffset=NULL;
  291.  WORD               gfxmode=NULL;
  292.  register LONG srcbytes,dstbytes;
  293.  register UBYTE          *source;
  294.  register UBYTE            *dest;
  295.  register UBYTE         *scrbase;
  296.  register WORD               c,h;
  297.  
  298.  UBYTE            red,green,blue;
  299.  register UWORD    repeat = NULL;
  300.  
  301.  gfxmode = 12;
  302.  
  303.  if(USERFLGS & PFLG_TRUECLR)              
  304.  {
  305.   gfxmode = 24;
  306.   if(USERFLGS & PFLG_TC15BIT) gfxmode = 15;
  307.   if(USERFLGS & PFLG_TC16BIT) gfxmode = 16;
  308.  }
  309.  
  310.  scrbase = LockVillageScreen(s);
  311.  
  312.  if(!(USERFLGS & UFLG_NOCENTER)) 
  313.  {
  314.   switch(gfxmode)
  315.   {
  316.    case 12:
  317.    case 15:
  318.    case 16:
  319.  
  320.    scrbase += (((height) - (bmap->h)) / 2 * (width) * 2) + (((width) - (bmap->w)) / 2 * 2);
  321.    break;
  322.  
  323.    case 24:
  324.  
  325.    scrbase += (((height) - (bmap->h)) / 2 * (width) * 3) + (((width) - (bmap->w)) / 2 * 3);
  326.    break;
  327.   }
  328.  }
  329.  
  330.  srcbytes = ReadChunkBytes(iff,cbuf,cbufsize); /* Lesen der Daten nach cbuf */
  331.  source = cbuf;
  332.  
  333.  if(gfxmode != 12)
  334.  {
  335.  
  336.   for(h=0; h < (bmap->h); h++)
  337.   {
  338.    dest = &scrbase[pixoffset];
  339.  
  340.    dstbytes = bmap->w;
  341.  
  342.    while(dstbytes > 0)
  343.    {
  344.  
  345.     if(!repeat) /* 1) Wdh.zähler kann über eine Zeile hinaus reichen */
  346.     {
  347.  
  348.      if((srcbytes -= 4) < 0) 
  349.      {
  350.       srcbytes += 4;
  351.  
  352.       for(c=0; c < srcbytes; c++) cbuf[c] = *source++;
  353.  
  354.       if(ReadChunkBytes(iff,&cbuf[srcbytes],cbufsize - srcbytes) < 0) 
  355.       {
  356.        ok = FALSE;
  357.        goto RGBxError;
  358.       }
  359.       srcbytes = cbufsize-4;
  360.       source = cbuf;
  361.      }
  362.  
  363.      red    = *source++;
  364.      green  = *source++;
  365.      blue   = *source++;
  366.      repeat = (UWORD)(*source++ & 0x007f);
  367.  
  368.      if(!repeat)
  369.      {
  370.  
  371.       if((srcbytes -= 1) < 0)
  372.       {
  373.  
  374.        if(ReadChunkBytes(iff,cbuf,cbufsize) < 0)
  375.        {
  376.         ok = FALSE;
  377.         goto RGBxError;
  378.        }
  379.        srcbytes = cbufsize - 1;
  380.        source = cbuf;
  381.       }
  382.  
  383.       if(!(repeat = (UWORD)(*source++)))
  384.       {
  385.  
  386.        if((srcbytes -= 2) < 0) 
  387.        {
  388.         srcbytes += 2;
  389.  
  390.         for(c=0; c < srcbytes; c++) cbuf[c] = *source++;
  391.  
  392.         if(ReadChunkBytes(iff,&cbuf[srcbytes],cbufsize - srcbytes) < 0) 
  393.         {
  394.          ok = FALSE;
  395.          goto RGBxError;
  396.         }
  397.         srcbytes = cbufsize-2;
  398.         source = cbuf;
  399.        }
  400.  
  401.        repeat = (UWORD)((*source++)<<8);
  402.        repeat += (UWORD)*source++;
  403.       }
  404.      } 
  405.     }
  406.  
  407.     if((dstbytes -= repeat) < 0) repeat += dstbytes; /* siehe 1) */
  408.     
  409.     do
  410.     {
  411.      switch(gfxmode)
  412.      {
  413.       case 15:
  414.  
  415.       *dest++ = ((green<<2)&0xE0) | ((blue>>3)&0x1F);
  416.       *dest++ = ((green>>6)&0x03) | ((red>>1)&0x7C);
  417.       break;
  418.  
  419.       case 16:
  420.  
  421.       *dest++ = ((green<<3)&0xE0) | ((blue>>3)&0x1F);
  422.       *dest++ = ((green>>5)&0x07) | (red&0xF8);
  423.       break;
  424.  
  425.       case 24:
  426.  
  427.       *dest++ = blue;
  428.       *dest++ = green;
  429.       *dest++ = red; 
  430.       break;
  431.      }
  432.     } while(--repeat > 0);
  433.  
  434.     if(dstbytes < 0) /* siehe 1) */
  435.     {
  436.      repeat = -dstbytes;
  437.      break;
  438.     }
  439.  
  440.    }
  441.    switch(gfxmode)
  442.    {
  443.     case 15:
  444.     case 16:
  445.     pixoffset += width * 2;
  446.     break;
  447.  
  448.     case 24:
  449.     pixoffset += width * 3;
  450.     break;
  451.    }
  452.   }
  453.  }
  454.  else
  455.  {
  456.  
  457.   for(h=0; h < (bmap->h); h++)
  458.   {
  459.    dest = &scrbase[pixoffset];
  460.  
  461.    dstbytes = (LONG)bmap->w;
  462.  
  463.    while(dstbytes > 0)
  464.    {
  465.  
  466.     if(!repeat) /* 1) Wdh.zähler kann über eine Zeile hinaus reichen */
  467.     {
  468.  
  469.      if((srcbytes -= 2) < 0) 
  470.      {
  471.       srcbytes += 2;
  472.  
  473.       for(c=0; c < srcbytes; c++) cbuf[c] = *source++;
  474.  
  475.       if(ReadChunkBytes(iff,&cbuf[srcbytes],cbufsize - srcbytes) < 0) 
  476.       {
  477.        ok = FALSE;
  478.        goto RGBxError;
  479.       }
  480.       srcbytes = cbufsize - 2;
  481.       source = cbuf;
  482.      }
  483.  
  484.      red    = *source & 0xf0;
  485.      green  = (*source++<<4) & 0xf0;
  486.      blue   = *source & 0xf0;
  487.      repeat = (UWORD)(*source++ & 0x07);
  488.  
  489.      if(!repeat)
  490.      {
  491.  
  492.       if((srcbytes -= 1) < 0)
  493.       {
  494.  
  495.        if(ReadChunkBytes(iff,cbuf,cbufsize) < 0)
  496.        {
  497.         ok = FALSE;
  498.         goto RGBxError;
  499.        }
  500.        srcbytes = cbufsize - 1;
  501.        source = cbuf;
  502.       }
  503.  
  504.       if(!(repeat = (UWORD)(*source++)))
  505.       {
  506.  
  507.        if((srcbytes -= 2) < 0) 
  508.        {
  509.         srcbytes += 2;
  510.  
  511.         for(c=0; c < srcbytes; c++) cbuf[c] = *source++;
  512.  
  513.         if(ReadChunkBytes(iff,&cbuf[srcbytes],cbufsize - srcbytes) < 0) 
  514.         {
  515.          ok = FALSE;
  516.          goto RGBxError;
  517.         }
  518.         srcbytes = cbufsize - 2;
  519.         source = cbuf;
  520.        }
  521.  
  522.        repeat = (UWORD)((*source++)<<8);
  523.        repeat += (UWORD)*source++;
  524.       }
  525.      } 
  526.     }
  527.  
  528.     if((dstbytes -= repeat) < 0) repeat += dstbytes; /* siehe 1) */
  529.     
  530.     do
  531.     {
  532.      *dest++ = ((green<<2)&0xE0) | ((blue>>3)&0x1F);
  533.      *dest++ = ((green>>6)&0x03) | ((red>>1)&0x7C);
  534.     } while(--repeat > 0);
  535.  
  536.     if(dstbytes < 0) /* siehe 1) */
  537.     {
  538.      repeat = -dstbytes;
  539.      break;
  540.     }
  541.  
  542.    }
  543.    pixoffset += width * 2;
  544.   }
  545.  }
  546.  
  547. RGBxError:
  548.  
  549.  UnLockVillageScreen(s); 
  550.  
  551.  return(ok);
  552. }
  553.